ટાઇપસ્ક્રીપ્ટ જેનરિક્સ: મજબૂત એપ્લિકેશન્સ માટે જટિલ ડેટા પ્રકારોમાં નિપુણતા

ટાઇપસ્ક્રીપ્ટ, જાવાસ્ક્રિપ્ટનો એક સુપરસેટ, ડેવલપર્સને સ્ટેટિક ટાઇપિંગ દ્વારા વધુ મજબૂત અને જાળવણી કરી શકાય તેવો કોડ લખવા માટે સશક્ત બનાવે છે. તેની સૌથી શક્તિશાળી સુવિધાઓમાં જેનરિક્સ છે, જે તમને ટાઇપ સેફ્ટી જાળવી રાખીને વિવિધ ડેટા પ્રકારો સાથે કામ કરી શકે તેવો કોડ લખવાની મંજૂરી આપે છે. આ માર્ગદર્શિકા ટાઇપસ્ક્રીપ્ટ જેનરિક્સનું વિસ્તૃત સંશોધન પૂરું પાડે છે, જે વૈશ્વિક સોફ્ટવેર ડેવલપમેન્ટના સંદર્ભમાં જટિલ ડેટા પ્રકારો પર તેમના એપ્લિકેશન પર ધ્યાન કેન્દ્રિત કરે છે.

જેનરિક્સ શું છે?

જેનરિક્સ પુનઃઉપયોગી કોડ લખવાની એક રીત પૂરી પાડે છે જે વિવિધ પ્રકારો સાથે કામ કરી શકે છે. તમે જે દરેક પ્રકારને સપોર્ટ કરવા માંગો છો તેના માટે અલગ-અલગ ફંક્શન્સ અથવા ક્લાસ લખવાને બદલે, તમે એક જ ફંક્શન અથવા ક્લાસ લખી શકો છો જે ટાઇપ પેરામીટર્સનો ઉપયોગ કરે છે. આ ટાઇપ પેરામીટર્સ તે વાસ્તવિક પ્રકારો માટે પ્લેસહોલ્ડર્સ છે જેનો ઉપયોગ ફંક્શન અથવા ક્લાસને કૉલ કરવામાં આવે ત્યારે અથવા ઇન્સ્ટેન્શિએટ કરવામાં આવે ત્યારે થશે. આ ખાસ કરીને જટિલ ડેટા સ્ટ્રક્ચર્સ સાથે કામ કરતી વખતે ઉપયોગી છે જ્યાં તે સ્ટ્રક્ચર્સની અંદરના ડેટાનો પ્રકાર અલગ-અલગ હોઈ શકે છે.

જેનરિક્સનો ઉપયોગ કરવાના ફાયદા

• કોડ પુનઃઉપયોગિતા: કોડ એકવાર લખો અને તેનો વિવિધ પ્રકારો સાથે ઉપયોગ કરો. આ કોડ ડુપ્લિકેશન ઘટાડે છે અને તમારા કોડબેઝને વધુ જાળવણી કરી શકાય તેવું બનાવે છે.
• ટાઇપ સેફ્ટી: જેનરિક્સ ટાઇપસ્ક્રીપ્ટ કમ્પાઇલરને કમ્પાઇલ સમયે ટાઇપ સેફ્ટી લાગુ કરવાની મંજૂરી આપે છે. આ ટાઇપ મિસમેચ સંબંધિત રનટાઇમ ભૂલોને રોકવામાં મદદ કરે છે.
• સુધારેલી વાંચનક્ષમતા: જેનરિક્સ તમારા ફંક્શન્સ અને ક્લાસ કયા પ્રકારો સાથે કામ કરવા માટે ડિઝાઇન કરવામાં આવ્યા છે તે સ્પષ્ટપણે દર્શાવીને તમારા કોડને વધુ વાંચનીય બનાવે છે.
• વધારેલું પ્રદર્શન: કેટલાક કિસ્સાઓમાં, જેનરિક્સ પ્રદર્શનમાં સુધારો કરી શકે છે કારણ કે કમ્પાઇલર ઉપયોગમાં લેવાતા વિશિષ્ટ પ્રકારોના આધારે જનરેટ કરેલા કોડને ઓપ્ટિમાઇઝ કરી શકે છે.

જેનરિક્સનો મૂળભૂત સિન્ટેક્સ

જેનરિક્સના મૂળભૂત સિન્ટેક્સમાં ટાઇપ પેરામીટર્સ જાહેર કરવા માટે એંગલ બ્રેકેટ્સ (< >) નો ઉપયોગ શામેલ છે. આ ટાઇપ પેરામીટર્સને સામાન્ય રીતે T, K, V, વગેરે નામ આપવામાં આવે છે, પરંતુ તમે કોઈપણ માન્ય આઇડેન્ટિફાયરનો ઉપયોગ કરી શકો છો. અહીં એક જેનરિક ફંક્શનનું સરળ ઉદાહરણ છે:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);
let myBoolean: boolean = identity<boolean>(true);

console.log(myString); // Output: hello
console.log(myNumber); // Output: 123
console.log(myBoolean); // Output: true

આ ઉદાહરણમાં, <T> એ T નામના ટાઇપ પેરામીટરને જાહેર કરે છે. identity ફંક્શન T પ્રકારનો એક આર્ગ્યુમેન્ટ લે છે અને T પ્રકારનું મૂલ્ય પરત કરે છે. ફંક્શનને કૉલ કરતી વખતે, તમે સ્પષ્ટપણે ટાઇપ પેરામીટરનો ઉલ્લેખ કરી શકો છો (દા.ત., identity<string>) અથવા ટાઇપસ્ક્રીપ્ટને આર્ગ્યુમેન્ટ પ્રકારના આધારે તેનો અનુમાન કરવા દઈ શકો છો.

જટિલ ડેટા પ્રકારો સાથે કામ કરવું

જેનરિક્સ ખાસ કરીને જ્યારે એરે, ઓબ્જેક્ટ્સ અને ઇન્ટરફેસ જેવા જટિલ ડેટા પ્રકારો સાથે કામ કરતી વખતે મૂલ્યવાન બને છે. ચાલો કેટલાક સામાન્ય દૃશ્યોનું અન્વેષણ કરીએ:

જેનરિક એરે

તમે જેનરિક્સનો ઉપયોગ એવા ફંક્શન્સ અથવા ક્લાસ બનાવવા માટે કરી શકો છો જે વિવિધ પ્રકારના એરે સાથે કામ કરે છે:

function arrayToString<T>(arr: T[]): string {
  return arr.join(", ");
}

let numberArray: number[] = [1, 2, 3, 4, 5];
let stringArray: string[] = ["apple", "banana", "cherry"];

console.log(arrayToString(numberArray)); // Output: 1, 2, 3, 4, 5
console.log(arrayToString(stringArray)); // Output: apple, banana, cherry

અહીં, arrayToString ફંક્શન T[] પ્રકારનો એક એરે લે છે અને એરેનું સ્ટ્રિંગ પ્રતિનિધિત્વ પરત કરે છે. આ ફંક્શન કોઈપણ પ્રકારના એરે સાથે કામ કરે છે, જે તેને અત્યંત પુનઃઉપયોગી બનાવે છે.

જેનરિક ઓબ્જેક્ટ્સ

જેનરિક્સનો ઉપયોગ એવા ફંક્શન્સ અથવા ક્લાસને વ્યાખ્યાયિત કરવા માટે પણ થઈ શકે છે જે વિવિધ આકારના ઓબ્જેક્ટ્સ સાથે કામ કરે છે:

interface Person {
  name: string;
  age: number;
  country: string; // Added country for global context
}

interface Product {
  id: number;
  name: string;
  price: number;
  currency: string; // Added currency for global context
}

function displayInfo<T extends { name: string }>(item: T): void {
  console.log(`Name: ${item.name}`);
}

let person: Person = { name: "Alice", age: 30, country: "USA" };
let product: Product = { id: 1, name: "Laptop", price: 1200, currency: "USD" };

displayInfo(person); // Output: Name: Alice
displayInfo(product); // Output: Name: Laptop

આ ઉદાહરણમાં, displayInfo ફંક્શન T પ્રકારનો એક ઓબ્જેક્ટ લે છે જેમાં સ્ટ્રિંગ પ્રકારની name પ્રોપર્ટી હોવી જ જોઈએ. extends { name: string } ક્લોઝ એક કન્સ્ટ્રેઇન્ટ (મર્યાદા) છે, જે ટાઇપ પેરામીટર T માટેની ન્યૂનતમ આવશ્યકતાઓને સ્પષ્ટ કરે છે. આ ખાતરી કરે છે કે ફંક્શન સુરક્ષિત રીતે name પ્રોપર્ટીને એક્સેસ કરી શકે છે.

અદ્યતન જેનરિક ઉપયોગ

ટાઇપસ્ક્રીપ્ટ જેનરિક્સ વધુ અદ્યતન સુવિધાઓ પ્રદાન કરે છે જે તમને વધુ લવચીક અને શક્તિશાળી કોડ બનાવવાની મંજૂરી આપે છે. ચાલો આમાંની કેટલીક સુવિધાઓનું અન્વેષણ કરીએ:

બહુવિધ ટાઇપ પેરામીટર્સ

તમે બહુવિધ ટાઇપ પેરામીટર્સ સાથે ફંક્શન્સ અથવા ક્લાસ વ્યાખ્યાયિત કરી શકો છો:

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

interface Name {
  firstName: string;
}

interface Age {
  age: number;
}

const person: Name = { firstName: "Bob" };
const details: Age = { age: 42 };

const merged = merge(person, details);
console.log(merged.firstName); // Output: Bob
console.log(merged.age); // Output: 42

merge ફંક્શન T અને U પ્રકારના બે ઓબ્જેક્ટ્સ લે છે અને એક નવો ઓબ્જેક્ટ પરત કરે છે જેમાં બંને ઓબ્જેક્ટ્સની પ્રોપર્ટીઝ હોય છે. આ વિવિધ સ્રોતોમાંથી ડેટાને જોડવાની એક શક્તિશાળી રીત છે.

જેનરિક કન્સ્ટ્રેઇન્ટ્સ (મર્યાદાઓ)

જેમ કે પહેલા બતાવવામાં આવ્યું છે, કન્સ્ટ્રેઇન્ટ્સ તમને જેનરિક ટાઇપ પેરામીટર સાથે ઉપયોગમાં લઈ શકાય તેવા પ્રકારોને પ્રતિબંધિત કરવાની મંજૂરી આપે છે. આ ખાતરી કરે છે કે જેનરિક કોડ નિર્દિષ્ટ પ્રકારો પર સુરક્ષિત રીતે કાર્ય કરી શકે છે.

interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

loggingIdentity([1, 2, 3]); // Output: 3
loggingIdentity("hello"); // Output: 5
// loggingIdentity(123); // Error: Argument of type 'number' is not assignable to parameter of type 'Lengthwise'.

loggingIdentity ફંક્શન T પ્રકારનો એક આર્ગ્યુમેન્ટ લે છે જેમાં નંબર પ્રકારની length પ્રોપર્ટી હોવી જ જોઈએ. આ ખાતરી કરે છે કે ફંક્શન સુરક્ષિત રીતે length પ્રોપર્ટીને એક્સેસ કરી શકે છે.

જેનરિક ક્લાસ

જેનરિક્સનો ઉપયોગ ક્લાસ સાથે પણ થઈ શકે છે:

class DataStorage<T> {
  private data: T[] = [];

  addItem(item: T) {
    this.data.push(item);
  }

  removeItem(item: T) {
    this.data = this.data.filter(d => d !== item);
  }

  getItems(): T[] {
    return [...this.data];
  }
}

const textStorage = new DataStorage<string>();
textStorage.addItem("apple");
textStorage.addItem("banana");
textStorage.removeItem("apple");
console.log(textStorage.getItems()); // Output: [ 'banana' ]

const numberStorage = new DataStorage<number>();
numberStorage.addItem(1);
numberStorage.addItem(2);
numberStorage.removeItem(1);
console.log(numberStorage.getItems()); // Output: [ 2 ]

DataStorage ક્લાસ કોઈપણ પ્રકાર T ના ડેટાને સ્ટોર કરી શકે છે. આ તમને પુનઃઉપયોગી ડેટા સ્ટ્રક્ચર્સ બનાવવાની મંજૂરી આપે છે જે ટાઇપ-સેફ હોય છે.

જેનરિક ઇન્ટરફેસ

જેનરિક ઇન્ટરફેસ વિવિધ પ્રકારો સાથે કામ કરી શકે તેવા કોન્ટ્રાક્ટ્સને વ્યાખ્યાયિત કરવા માટે ઉપયોગી છે. ઉદાહરણ તરીકે:

interface Result<T, E> {
  success: boolean;
  data?: T;
  error?: E;
}

interface User {
  id: number;
  username: string;
  email: string;
}

interface ErrorMessage {
  code: number;
  message: string;
}

function fetchUser(id: number): Result<User, ErrorMessage> {
  if (id === 1) {
    return { success: true, data: { id: 1, username: "john.doe", email: "john.doe@example.com" } };
  } else {
    return { success: false, error: { code: 404, message: "User not found" } };
  }
}

const userResult = fetchUser(1);
if (userResult.success) {
  console.log(userResult.data.username);
} else {
  console.log(userResult.error.message);
}

Result ઇન્ટરફેસ કોઈ ઓપરેશનના પરિણામને રજૂ કરવા માટે એક જેનરિક માળખું વ્યાખ્યાયિત કરે છે. તેમાં કાં તો T પ્રકારનો ડેટા અથવા E પ્રકારની એરર હોઈ શકે છે. આ એસિંક્રોનસ ઓપરેશન્સ અથવા નિષ્ફળ થઈ શકે તેવા ઓપરેશન્સને હેન્ડલ કરવા માટે એક સામાન્ય પેટર્ન છે.

યુટિલિટી ટાઇપ્સ અને જેનરિક્સ

ટાઇપસ્ક્રીપ્ટ ઘણા બિલ્ટ-ઇન યુટિલિટી ટાઇપ્સ પ્રદાન કરે છે જે જેનરિક્સ સાથે સારી રીતે કામ કરે છે. આ યુટિલિટી ટાઇપ્સ તમને શક્તિશાળી રીતે પ્રકારોને રૂપાંતરિત અને હેરફેર કરવામાં મદદ કરી શકે છે.

Partial<T>

Partial<T> એ T પ્રકારની બધી પ્રોપર્ટીઝને વૈકલ્પિક બનાવે છે:

interface Person {
  name: string;
  age: number;
}

type PartialPerson = Partial<Person>;

const partialPerson: PartialPerson = { name: "Alice" }; // Valid

Readonly<T>

Readonly<T> એ T પ્રકારની બધી પ્રોપર્ટીઝને ફક્ત-વાંચવા માટેની (readonly) બનાવે છે:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = Readonly<Person>;

const readonlyPerson: ReadonlyPerson = { name: "Bob", age: 42 };
// readonlyPerson.age = 43; // Error: Cannot assign to 'age' because it is a read-only property.

Pick<T, K>

Pick<T, K> એ T પ્રકારમાંથી K પ્રોપર્ટીઝના સેટને પસંદ કરે છે:

interface Person {
  name: string;
  age: number;
  email: string;
}

type NameAndAge = Pick<Person, "name" | "age">;

const nameAndAge: NameAndAge = { name: "Charlie", age: 28 };

Omit<T, K>

Omit<T, K> એ T પ્રકારમાંથી K પ્રોપર્ટીઝના સેટને દૂર કરે છે:

interface Person {
  name: string;
  age: number;
  email: string;
}

type PersonWithoutEmail = Omit<Person, "email">;

const personWithoutEmail: PersonWithoutEmail = { name: "David", age: 35 };

Record<K, T>

Record<K, T> એ K કીઝ અને T પ્રકારના મૂલ્યો સાથેનો એક પ્રકાર બનાવે છે:

type CountryCodes = "US" | "CA" | "UK" | "DE" | "FR" | "JP" | "CN" | "IN" | "BR" | "AU"; // Expanded list for global context
type Currency = "USD" | "CAD" | "GBP" | "EUR" | "JPY" | "CNY" | "INR" | "BRL" | "AUD"; // Expanded list for global context

type CurrencyMap = Record<CountryCodes, Currency>;

const currencyMap: CurrencyMap = {
  "US": "USD",
  "CA": "CAD",
  "UK": "GBP",
  "DE": "EUR",
  "FR": "EUR",
  "JP": "JPY",
  "CN": "CNY",
  "IN": "INR",
  "BR": "BRL",
  "AU": "AUD",
};

મેપ્ડ ટાઇપ્સ

મેપ્ડ ટાઇપ્સ તમને હાલના પ્રકારોની પ્રોપર્ટીઝ પર પુનરાવર્તન કરીને તેમને રૂપાંતરિત કરવાની મંજૂરી આપે છે. આ હાલના પ્રકારોના આધારે નવા પ્રકારો બનાવવાની એક શક્તિશાળી રીત છે. ઉદાહરણ તરીકે, તમે એક એવો પ્રકાર બનાવી શકો છો જે બીજા પ્રકારની બધી પ્રોપર્ટીઝને ફક્ત-વાંચવા માટેની (readonly) બનાવે છે:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = {
  readonly [K in keyof Person]: Person[K];
};

const readonlyPerson: ReadonlyPerson = { name: "Eve", age: 25 };
// readonlyPerson.age = 26; // Error: Cannot assign to 'age' because it is a read-only property.

આ ઉદાહરણમાં, [K in keyof Person] એ Person ઇન્ટરફેસની બધી કીઝ પર પુનરાવર્તન કરે છે, અને Person[K] દરેક પ્રોપર્ટીના પ્રકારને એક્સેસ કરે છે. readonly કીવર્ડ દરેક પ્રોપર્ટીને ફક્ત-વાંચવા માટેની બનાવે છે.

કન્ડિશનલ ટાઇપ્સ

કન્ડિશનલ ટાઇપ્સ તમને શરતોના આધારે પ્રકારોને વ્યાખ્યાયિત કરવાની મંજૂરી આપે છે. આ વિવિધ દૃશ્યોને અનુરૂપ પ્રકારો બનાવવાની એક શક્તિશાળી રીત છે.

type NonNullable<T> = T extends null | undefined ? never : T;

type MaybeString = string | null | undefined;
type StringType = NonNullable<MaybeString>; // string

function getValue<T>(value: T): NonNullable<T> {
  if (value == null) { // Handles both null and undefined
    throw new Error("Value cannot be null or undefined");
  }
  return value as NonNullable<T>;
}

try {
  const validValue = getValue("hello");
  console.log(validValue.toUpperCase()); // Output: HELLO

  const invalidValue = getValue(null); // This will throw an error
  console.log(invalidValue); // This line will not be reached
} catch (error: any) {
  console.error(error.message); // Output: Value cannot be null or undefined
}

આ ઉદાહરણમાં, NonNullable<T> પ્રકાર તપાસે છે કે T એ null છે કે undefined. જો તે હોય, તો તે never પરત કરે છે, જેનો અર્થ છે કે તે પ્રકારને મંજૂરી નથી. અન્યથા, તે T પરત કરે છે. આ તમને એવા પ્રકારો બનાવવાની મંજૂરી આપે છે જે નોન-નલેબલ હોવાની ખાતરી આપે છે.

જેનરિક્સનો ઉપયોગ કરવા માટેની શ્રેષ્ઠ પદ્ધતિઓ

અહીં જેનરિક્સનો ઉપયોગ કરતી વખતે ધ્યાનમાં રાખવા જેવી કેટલીક શ્રેષ્ઠ પદ્ધતિઓ છે:

• વર્ણનાત્મક ટાઇપ પેરામીટર નામોનો ઉપયોગ કરો: એવા નામો પસંદ કરો જે ટાઇપ પેરામીટરના હેતુને સ્પષ્ટપણે દર્શાવે છે.
• જેનરિક ટાઇપ પેરામીટર સાથે ઉપયોગમાં લઈ શકાય તેવા પ્રકારોને મર્યાદિત કરવા માટે કન્સ્ટ્રેઇન્ટ્સનો ઉપયોગ કરો: આ ખાતરી કરે છે કે તમારો જેનરિક કોડ નિર્દિષ્ટ પ્રકારો પર સુરક્ષિત રીતે કાર્ય કરી શકે છે.
• તમારા જેનરિક કોડને સરળ અને કેન્દ્રિત રાખો: ઘણા બધા ટાઇપ પેરામીટર્સ અથવા જટિલ કન્સ્ટ્રેઇન્ટ્સ સાથે તમારા જેનરિક કોડને વધુ જટિલ બનાવવાનું ટાળો.
• તમારા જેનરિક કોડને સંપૂર્ણ રીતે દસ્તાવેજીકૃત કરો: ટાઇપ પેરામીટર્સના હેતુ અને ઉપયોગમાં લેવાતા કોઈપણ કન્સ્ટ્રેઇન્ટ્સને સમજાવો.
• કોડ પુનઃઉપયોગિતા અને ટાઇપ સેફ્ટી વચ્ચેના ટ્રેડ-ઓફ્સને ધ્યાનમાં લો: જ્યારે જેનરિક્સ કોડ પુનઃઉપયોગિતામાં સુધારો કરી શકે છે, ત્યારે તે તમારા કોડને વધુ જટિલ પણ બનાવી શકે છે. જેનરિક્સનો ઉપયોગ કરતા પહેલા ફાયદા અને ગેરફાયદાનું મૂલ્યાંકન કરો.
• સ્થાનિકીકરણ અને વૈશ્વિકીકરણ (l10n અને g11n) નો વિચાર કરો: જ્યારે વિવિધ પ્રદેશોમાં વપરાશકર્તાઓને પ્રદર્શિત કરવાની જરૂર હોય તેવા ડેટા સાથે કામ કરતા હોવ, ત્યારે ખાતરી કરો કે તમારા જેનરિક્સ યોગ્ય ફોર્મેટિંગ અને સાંસ્કૃતિક સંમેલનોને સમર્થન આપે છે. ઉદાહરણ તરીકે, સંખ્યા અને તારીખ ફોર્મેટિંગ વિવિધ સ્થળોએ નોંધપાત્ર રીતે અલગ હોઈ શકે છે.

વૈશ્વિક સંદર્ભમાં ઉદાહરણો

ચાલો કેટલાક ઉદાહરણો ધ્યાનમાં લઈએ કે વૈશ્વિક સંદર્ભમાં જેનરિક્સનો કેવી રીતે ઉપયોગ કરી શકાય છે:

ચલણ રૂપાંતર

interface ConversionRate {
  rate: number;
  fromCurrency: string;
  toCurrency: string;
}

function convertCurrency<T extends ConversionRate>(amount: number, rate: T): number {
  return amount * rate.rate;
}

const usdToEurRate: ConversionRate = { rate: 0.85, fromCurrency: "USD", toCurrency: "EUR" };
const amountInUSD = 100;
const amountInEUR = convertCurrency(amountInUSD, usdToEurRate);
console.log(`${amountInUSD} USD is equal to ${amountInEUR} EUR`); // Output: 100 USD is equal to 85 EUR

તારીખ ફોર્મેટિંગ

interface DateFormatOptions {
  locale: string;
  options: Intl.DateTimeFormatOptions;
}

function formatDate<T extends DateFormatOptions>(date: Date, format: T): string {
  return date.toLocaleDateString(format.locale, format.options);
}

const currentDate = new Date();

const usDateFormat: DateFormatOptions = { locale: "en-US", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const germanDateFormat: DateFormatOptions = { locale: "de-DE", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const japaneseDateFormat: DateFormatOptions = { locale: "ja-JP", options: { year: 'numeric', month: 'long', day: 'numeric' } };

console.log("US Date: " + formatDate(currentDate, usDateFormat));
console.log("German Date: " + formatDate(currentDate, germanDateFormat));
console.log("Japanese Date: " + formatDate(currentDate, japaneseDateFormat));

અનુવાદ સેવા

interface Translation {
  [key: string]: string; // Allows for dynamic language keys
}

interface LanguageData<T extends Translation> {
  languageCode: string;
  translations: T;
}

const englishTranslations: Translation = {
  "hello": "Hello",
  "goodbye": "Goodbye",
  "welcome": "Welcome to our website!"
};

const spanishTranslations: Translation = {
  "hello": "Hola",
  "goodbye": "Adiós",
  "welcome": "¡Bienvenido a nuestro sitio web!"
};

const frenchTranslations: Translation = {
  "hello": "Bonjour",
  "goodbye": "Au revoir",
  "welcome": "Bienvenue sur notre site web !"
};


const languageData: LanguageData<typeof englishTranslations>[] = [
  {languageCode: "en", translations: englishTranslations },
  {languageCode: "es", translations: spanishTranslations },
  {languageCode: "fr", translations: frenchTranslations}
];

function translate<T extends Translation>(key: string, languageCode: string, languageData: LanguageData<T>[]): string {
  const lang = languageData.find(lang => lang.languageCode === languageCode);
  if (!lang) {
    return `Translation for ${key} in ${languageCode} not found.`;
  }
  return lang.translations[key] || `Translation for ${key} not found.`;
}

console.log(translate("hello", "en", languageData)); // Output: Hello
console.log(translate("hello", "es", languageData)); // Output: Hola
console.log(translate("welcome", "fr", languageData)); // Output: Bienvenue sur notre site web !
console.log(translate("missingKey", "de", languageData)); // Output: Translation for missingKey in de not found.

નિષ્કર્ષ

ટાઇપસ્ક્રીપ્ટ જેનરિક્સ પુનઃઉપયોગી, ટાઇપ-સેફ કોડ લખવા માટે એક શક્તિશાળી સાધન છે જે જટિલ ડેટા પ્રકારો સાથે કામ કરી શકે છે. જેનરિક્સના મૂળભૂત સિન્ટેક્સ, અદ્યતન સુવિધાઓ અને શ્રેષ્ઠ પદ્ધતિઓને સમજીને, તમે તમારી ટાઇપસ્ક્રીપ્ટ એપ્લિકેશન્સની ગુણવત્તા અને જાળવણીક્ષમતામાં નોંધપાત્ર સુધારો કરી શકો છો. વૈશ્વિક પ્રેક્ષકો માટે એપ્લિકેશન્સ વિકસાવતી વખતે, જેનરિક્સ તમને વિવિધ ડેટા ફોર્મેટ્સ અને સાંસ્કૃતિક સંમેલનોને સંભાળવામાં મદદ કરી શકે છે, જે દરેક માટે એક સમાન વપરાશકર્તા અનુભવ સુનિશ્ચિત કરે છે.